Lambda the Ultimate

Niklaus Wirth discusses two of his Pascal successor languages in the HOPL-III paper on Modula-2 and Oberon.

This is an account of the development of the languages Modula-2 and Oberon. Together with their ancestors ALGOL 60 and Pascal they form a family called Algol-like languages. Pascal (1970) reflected the ideas of Structured Programming, Modula-2 (1979) added those of modular system design, and Oberon (1988) catered to the object-oriented style. Thus they mirror the essential programming paradigms of the past decades. Here the major language properties are outlined, followed by an account of the respective implementation efforts. The conditions and the environments are elucidated, in which the languages were created. We point out that simplicity of design was the most essential, guiding principle. Clarity of concepts, economy of features, efficiency and reliability of implementations were its consequences.

The main influence on these languages were the Xerox Parc languages of Mesa and Cedar (which were Pascal derivatives). Mesa and Modula-2 explored modules, while Cedar and Oberon were concerned with the entire operating system experience. As Wirth states a couple of times in the paper, his main goal was to teach programming concepts, using language design to further that end, but with an eye for use in non-academic settings. He frowns on the design of modern PLs, with its lack of resource constraints and kitchen-sink approaches - expressing concern that it makes it hard to teach structured programming. He also expresses concern that operating systems are no longer a subject of research, much less integration with PL design.

(Previous LtU links to HOPL-III papers.)

Designing High-Security Systems: A Comparison of Programming Languages. Ben Brosgol. STSC.

The high degree of interconnectivity in today’s computing systems and the increasing threat from technically sophisticated adversaries make security an essential requirement in modern military software. Many technical factors affect the ease or difficulty of meeting this requirement, including the programming language, the software development tools, the operating system, and the application program interface. This presentation focuses on the programming language, which is arguably the factor that a development project manager can control most directly, and assesses three major language families with respect to the criteria that a secure system must meet:

* Ada 2005 and the Ada-based SPARK language
* C and C++
* Java and its relevant extensions (Real-Time Specification for Java, Safety-Critical Real-Time Java)

The presentation focuses in particular on how modern language features (such as the data type model, Object-Oriented Programming ("OOP"), exception handling, and concurrency) affect application security, and compares the requirememts for security and for safety.

Not overly technical, but a useful summary none the less.

Registration for the 10th ICFP Programming Contest is now open.

You can register via the homepage of the contest:

http://www.icfpcontest.org/

-- The organisation team

CLL: A Concurrent Language Built from Logical Principles by Deepak Garg, 2005.

In this report, we use both the Curry-Howard isomorphism and proof-search to design a concurrent programming language from logical principles. ... Our underlying logic is a first-order intuitionistic linear logic where all right synchronous connectives are restricted to a monad.

Yet another example of using monads to embed effectful computations into a pure FP. Another interesting part is the methodology of derivation of a PL from a logic.

The Artificial Intelligence Repository was established by Mark Kantrowitz in 1993 to collect files, programs and publications of interest to Artificial Intelligence researchers, educators, and students. It is an outgrowth of the Lisp Utilities Repository established by Mark in 1990 and his work on the FAQ (Frequently Asked Questions) postings for the AI, Lisp, Scheme, and Prolog newsgroups. The Lisp Utilities Repository has been merged into the AI Repository.

The CMU AI repository is a treasure trove of interesting source code. Here you'll find the Yale Haskell System, a *Lisp simulator for Connection Machine programming, obscure mailing-list archives, and God knows what else.

Leave a comment if you find anything particularly interesting in here :-)

Leo Brodie's books Thinking Forth and Starting Forth are now available for download and the first is back in print. This material had been hard to find for a long time!

Until yesterday, I wasn't aware of any web stores implemented in Haskell. Most users of languages like Haskell and ML tend to be focused on other kinds of applications. This sometimes leads to discussions about the "real-world suitability" of these languages, which we've occasionally seen here on LtU.

The next time the subject comes up, it will be possible to point to a real, complete web store written in Haskell, which was announced on Haskell-Cafe back in April. The store is Braintree Hemp, and the code behind it was written by Adam Peacock. It's an impressive program, written in a little over 4200 lines of Haskell, sporting the following features:

Singularity: Rethinking the Software Stack.
Galen C. Hunt; James R. Larus. April 2007

...Singularity systems incorporate three key architectural features: software-isolated processes for protection of programs and system services, contract-based channels for communication, and manifest-based programs for verification of system properties. We describe this foundation in detail and sketch the ongoing research in experimental systems that build upon it.

Singularity comes up in discussion every now and then. This seems like a nice and recent overview.

The word that he had long taken to mean "one" (hoi, on a falling tone) is used by the Pirahã to refer, more generally, to "a small size or amount," and the word for "two" (hoi, on a rising tone) is often used to mean "a somewhat larger size or amount."

Light reading from The New Yorker - April 16, 2007 about LtU's favourite amazonian tribe (previously on LtU Piraha Exceptionality: a Reassessment).

Alice ML team members Andreas Rossberg, Guido Tack & Leif Kornstaedt write about the implications of pickling for higher-order-type systems in their latest paper on HOT Pickles ...and how to serve them.

The need for flexible forms of serialisation arises under many circumstances, e.g. for doing high-level inter-process communication or to achieve persistence. Many languages, including variants of ML, thus offer pickling as a system service, but usually in a both unsafe and inexpressive manner, so that its use is discouraged. In contrast, safe generic pickling plays a central role in the design and implementation of Alice ML: components are defined as pickles, and modules can be exchanged between processes using pickling. For that purpose, pickling has to be higher-order and typed (HOT), i.e. embrace code mobility and involve runtime type checks for safety.

The paper makes the point that pickling should be considered an important aspect for programming language design. By making pickles first class, a number of related problems in open programming (serialization, distribution, modularity) can be directly addressed.